home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 1 / PC Actual CD 01.iso / f1 / cimb.arj / TGA.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-22  |  10.0 KB  |  456 lines
  1. /*==============================================================================
  2.  
  3. FICHERO: TGA.C
  4.  
  5. AUTOR: ANTONIO LADESA JURADO
  6.  
  7. FECHA: 24/6/94
  8.  
  9. DESCRIPCION:
  10.  
  11.     Fichero que contiene las estructuras, constantes, variables y funciones
  12.     internas y externas para el procesamiento de ficheros TGA.
  13.  
  14. ==============================================================================*/
  15.  
  16.  
  17. /*---- MODULOS USADOS --------------------------------------------------------*/
  18.  
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <alloc.h>
  22.  
  23. #include "global.h"
  24. #include "memoria.h"
  25. #include "video.h"
  26. #include "tga.h"
  27. #include "error.h"
  28.  
  29.  
  30. /*---- ESTRUCTURAS, CONSTANTES Y VARIABLES LOCALES AL MODULO -----------------*/
  31.  
  32.  
  33.     /* cabecera de un fichero TGA */
  34. typedef struct
  35.     {
  36.     char longitud;
  37.     char mapa_color;
  38.     char tipo_imagen;
  39.     int indice_mapa;
  40.     int entradas_mapa;
  41.     char tam_color;
  42.     int inf_izda_hor;
  43.     int inf_izda_ver;
  44.     int ancho;
  45.     int alto;
  46.     char prof_color_pixel;
  47.     char orden;
  48.     }
  49. CABtga;
  50.  
  51.     /* cabecera del fichero TGA */
  52. static CABtga cabecera;
  53.  
  54.  
  55. /*---- DEFINICION DE LAS FUNCIONES INTERNAS ----------------------------------*/
  56.  
  57.  
  58. IMAGEN *TGAleerCabecera(IMAGEN *c,FILE *f,char *nombre);
  59. IMAGEN *TGAleerImagen(IMAGEN *c,FILE *f);
  60. void TGAleerLinea(char *p, FILE *f,int bytes);
  61.  
  62. void TGAcrearCabecera(IMAGEN *c);
  63. void TGAescribirImagen(IMAGEN *c,FILE *f);
  64. void TGAescribirLinea(char *p,FILE *f,int bytes);
  65.  
  66.  
  67. /*---- CODIFICACION DE LAS FUNCIONES OFRECIDAS -------------------------------*/
  68.  
  69.  
  70. /*---- FUNCION: extern IMAGEN *TGAcargar(char *nombre,IMAGEN *c) ---------------
  71.  
  72.     Descripción:
  73.  
  74.         Esta función carga en memoria una imagen de tipo TGA.
  75.  
  76.     Parámetros:
  77.  
  78.         char *nombre : nombre del fichero a cargar
  79.         IMAGEN *c : puntero a estructura que alberga la imagen
  80.  
  81.     Retorno:
  82.  
  83.         Puntero a la estructura de la imagen o NULL si hubo error
  84.  
  85. ---- CODIGO: -----------------------------------------------------------------*/
  86.  
  87. extern IMAGEN *TGAcargar(char *nombre,IMAGEN *c)
  88. {
  89.     /* puntero al fichero de entrada */
  90. FILE *f;
  91.  
  92.     /* abrir fichero */
  93. if((f = fopen(nombre, "rb")) != NULL)
  94.     {
  95.         /* leer cabecera TGA */
  96.     if((c = TGAleerCabecera(c,f,nombre))!=NULL)
  97.         {
  98.             /* cargar imagen TGA */
  99.         TGAleerImagen(c,f);
  100.         }
  101.     }
  102. else
  103.     {
  104.     ERRORponer(ERRapertura);
  105.     return(NULL);
  106.     }
  107. return(c);
  108. }
  109.  
  110. /*---- FIN FUNCION -----------------------------------------------------------*/
  111.  
  112.  
  113. /*---- FUNCION: extern int *TGAsalvar(char *nombre,IMAGEN *c) ---------------
  114.  
  115.     Descripción:
  116.  
  117.         Esta función salva en disco una imagen con formato TGA.
  118.  
  119.     Parámetros:
  120.  
  121.         char *nombre : nombre del fichero a salvar
  122.         IMAGEN *c : puntero a estructura que alberga la imagen
  123.  
  124.     Retorno:
  125.  
  126.         - 0 si hay error
  127.         - 1 en caso contrario
  128.  
  129. ---- CODIGO: -----------------------------------------------------------------*/
  130.  
  131.     /* salvar un fichero TGA */
  132. extern int TGAsalvar(char *fichero,IMAGEN *c)
  133. {
  134.     /* puntero al fichero de salida */
  135. FILE *f;
  136.     /* contador */
  137. int i;
  138.  
  139.     /* abrir el fichero */
  140. if((f = fopen(fichero, "wb")) == NULL)
  141.     {
  142.     ERRORponer(ERRapertura);
  143.     return(0);
  144.     }
  145.  
  146.     /* si la imagen es monocromática se guarda en 8 pixels por byte */
  147. if(c->colores == 2 && c->modo != VIDEOmono)
  148.     c=VIDEOvision(c);
  149.  
  150.     /* crear la cabecera TGA */
  151. TGAcrearCabecera(c);
  152.  
  153.     /* escribir la cabecera TGA */
  154. if(fwrite((char *)&cabecera,1,sizeof(CABtga),f) != sizeof(CABtga))
  155.     {
  156.     ERRORponer(ERRapertura);
  157.     return(0);
  158.     }
  159.  
  160.     /* escribir paleta TGA que viene invertida (RGB -> BGR) */
  161. if(c->colores != 2)
  162.     for(i=0;i<c->colores*3;i+=3)
  163.         {
  164.         fputc(c->paleta[i+2],f);
  165.         fputc(c->paleta[i+1],f);
  166.         fputc(c->paleta[i],f);
  167.         }
  168.  
  169.     /* escribir la imagen TGA */
  170. TGAescribirImagen(c,f);
  171.  
  172. fclose(f);
  173. return(1);
  174. }
  175.  
  176. /*---- FIN FUNCION -----------------------------------------------------------*/
  177.  
  178.  
  179. /*---- CODIFICACION DE LAS FUNCIONES INTERNAS --------------------------------*/
  180.  
  181.  
  182. /*---- FUNCION: IMAGEN *TGAleerCabecera(IMAGEN *c,FILE *f,char *nombre) --------
  183.  
  184.     Descripción:
  185.  
  186.         Esta función reserva memoria para la imagen y lee la cabecera del fichero
  187.         TGA.
  188.  
  189.     Parámetros:
  190.  
  191.  
  192.         IMAGEN *c : puntero a estructura que alberga la imagen
  193.         FILE *f : puntero al fichero
  194.         char *nombre : nombre del fichero a cargar
  195.  
  196.     Retorno:
  197.  
  198.         Puntero a la estructura de la imagen o NULL si hubo error
  199.  
  200. ---- CODIGO: -----------------------------------------------------------------*/
  201.  
  202. IMAGEN *TGAleerCabecera(IMAGEN *c,FILE *f,char *nombre)
  203. {
  204.     /* leer cabecera TGA */
  205. if(fread((char *)&cabecera,1,sizeof(CABtga),f) != sizeof(CABtga))
  206.     {
  207.     ERRORponer(ERRlectura);
  208.     return(NULL);
  209.     }
  210.  
  211.     /* reservar memoria para la cabecera de trabajo */
  212. if((c=MEMreservarCAB(c))==NULL)
  213.     {
  214.     ERRORponer(ERRnoMemoria);
  215.     return(NULL);
  216.     }
  217.  
  218.     /* cargar cabecera de trabajo */
  219. strcpy(c->nombre,nombre);
  220. c->ancho = cabecera.ancho;
  221. c->alto = cabecera.alto;
  222. c->formato = TGA;
  223.  
  224.     /* determinar tipo de imagen */
  225. switch(cabecera.tipo_imagen)
  226.     {
  227.     case 1:
  228.     case 9:
  229.         c->modo = VIDEOvga;
  230.         c->bytes = (cabecera.prof_color_pixel / 8) * c->ancho;
  231.         c->colores = cabecera.entradas_mapa;
  232.         c->haypaleta = CIERTO;
  233.     break;
  234.  
  235.     case 3:
  236.     case 11:
  237.         c->modo = VIDEOmono;
  238.         c->bytes = DePixelsABytes(c->ancho);
  239.         c->colores = 2;
  240.         c->haypaleta = FALSO;
  241.     break;
  242.  
  243.     default:
  244.         c = MEMliberar(c);
  245.         ERRORponer(ERRnoTratado);
  246.     return(c);
  247.     };
  248.  
  249.     /* si tiene paleta propia, cargarla */
  250. if(cabecera.mapa_color)
  251.     {
  252.     fread((char *)c->paleta,1,(cabecera.tam_color/8)*cabecera.entradas_mapa,f);
  253.         /* la paleta de los ficheros TGA esta en formato BGR */
  254.     memcpy(c->paleta,VIDEOinvertirPaleta(c->paleta,c->colores),c->colores*3);
  255.     }
  256.  
  257.     /* si no hay memoria, liberar cabecera */
  258. if(!MEMreservar(c))
  259.     {
  260.     c = MEMliberar(c);
  261.     ERRORponer(ERRnoMemoria);
  262.     return(c);
  263.     }
  264. return(c);
  265. }
  266.  
  267. /*---- FIN FUNCION -----------------------------------------------------------*/
  268.  
  269.  
  270. /*---- FUNCION: IMAGEN *TGAleerImagen(IMAGEN *c,FILE *f) -----------------------
  271.  
  272.     Descripción:
  273.  
  274.         Esta función carga en memoria una imagen de tipo TGA.
  275.  
  276.     Parámetros:
  277.  
  278.  
  279.         IMAGEN *c : puntero a estructura que alberga la imagen
  280.         FILE *f : puntero al fichero
  281.  
  282.     Retorno:
  283.  
  284.         Puntero a la estructura de la imagen
  285.  
  286. ---- CODIGO: -----------------------------------------------------------------*/
  287.  
  288. IMAGEN *TGAleerImagen(IMAGEN *c,FILE *f)
  289. {
  290.     /* contador de lineas */
  291. int i;
  292.     /* buffer */
  293. char p[1024];
  294.     /* linea actual */
  295. int linea;
  296.  
  297.         /* cargar imagen */
  298.     for(i = 0; i < c->alto ; i++)
  299.         {
  300.             /* leer linea */
  301.         TGAleerLinea(p,f,c->bytes);
  302.             /* si estan en orden horizontal inverso, invertir linea */
  303.         if(cabecera.orden & 0x10)
  304.             memcpy(p,VIDEOinvertirLinea(c,p),c->bytes);
  305.             /* llevar la linea a memoria segun el orden vertical */
  306.         if(cabecera.orden & 0x20)
  307.             linea = i;
  308.         else
  309.             linea = c->alto-1-i;
  310.         MEMescribir(p,linea,c);
  311.         }
  312. return(c);
  313. }
  314.  
  315. /*---- FIN FUNCION -----------------------------------------------------------*/
  316.  
  317.  
  318. /*---- FUNCION: void TGAleerLinea(char *p, FILE *f,int bytes) ------------------
  319.  
  320.     Descripción:
  321.  
  322.         Esta función lee una línea de un fichero TGA.
  323.  
  324.     Parámetros:
  325.  
  326.         char *p : puntero a buffer donde se almacena la línea
  327.         FILE *f : puntero al fichero
  328.         int bytes: numero de bytes por linea
  329.  
  330. ---- CODIGO: -----------------------------------------------------------------*/
  331.  
  332. void TGAleerLinea(char *p, FILE *f,int bytes)
  333. {
  334. fread((char *)p,bytes,1,f);
  335. }
  336.  
  337. /*---- FIN FUNCION -----------------------------------------------------------*/
  338.  
  339.  
  340. /*---- FUNCION: void TGAcrearCabecera(IMAGEN *c) ------------------------------------
  341.  
  342.     Descripción:
  343.  
  344.         Esta función crea una cabecera TGA.
  345.  
  346.     Parámetros:
  347.  
  348.         IMAGEN *c : puntero a estructura que alberga la imagen
  349.  
  350. ---- CODIGO: -----------------------------------------------------------------*/
  351.  
  352. void TGAcrearCabecera(IMAGEN *c)
  353. {
  354.     /* rellena los datos de la cabecera */
  355. cabecera.longitud = 0;
  356. cabecera.inf_izda_hor = 0;
  357. cabecera.inf_izda_ver = 0;
  358. cabecera.ancho = c->ancho;
  359. cabecera.alto = c->alto;
  360. cabecera.orden = 0x20;
  361. switch(c->modo)
  362.     {
  363.     case VIDEOmono:
  364.         cabecera.mapa_color = 0;
  365.         cabecera.tipo_imagen = 3;
  366.         cabecera.indice_mapa = 0;
  367.         cabecera.entradas_mapa = 0;
  368.         cabecera.tam_color = 0;
  369.         cabecera.prof_color_pixel = 1;
  370.     break;
  371.     case VIDEOega:
  372.     case VIDEOvga:
  373.         cabecera.mapa_color = 1;
  374.         cabecera.tipo_imagen = 1;
  375.         cabecera.indice_mapa = 0;
  376.         cabecera.entradas_mapa = c->colores;
  377.         cabecera.tam_color = 24;
  378.         cabecera.prof_color_pixel = 8;
  379.     break;
  380.     }
  381. }
  382.  
  383. /*---- FIN FUNCION -----------------------------------------------------------*/
  384.  
  385.  
  386. /*---- FUNCION: void TGAescribirImagen(IMAGEN *c,FILE *f) ----------------
  387.  
  388.     Descripción:
  389.  
  390.         Esta función graba la imagen en un fichero TGA.
  391.  
  392.     Parámetros:
  393.  
  394.         IMAGEN *c : puntero a estructura que alberga la imagen
  395.         FILE *f : puntero al fichero
  396.  
  397. ---- CODIGO: -----------------------------------------------------------------*/
  398.  
  399. void TGAescribirImagen(IMAGEN *c,FILE *f)
  400. {
  401.     /* contador de lineas */
  402. int i;
  403.     /* buffers */
  404. char p[1024];
  405. char q[1024];
  406.  
  407.     /* salvar imagen */
  408. switch(c->modo)
  409.     {
  410.     case VIDEOmono:
  411.     case VIDEOvga:
  412.         for(i = 0; i < c->alto;++i)
  413.             {
  414.             MEMleer(p,i,c);
  415.             TGAescribirLinea(p,f,c->bytes);
  416.             }
  417.     break;
  418.         /* las imagenes EGA se transforman a VGA (1 byte por pixel) */
  419.     case VIDEOega:
  420.         for(i = 0; i < c->alto;++i)
  421.             {
  422.             MEMleer(p,i,c);
  423.             EGAaVGA(p,q,c->ancho);
  424.             TGAescribirLinea(q,f,c->ancho);
  425.             }
  426.     break;
  427.     }
  428. }
  429.  
  430. /*---- FIN FUNCION -----------------------------------------------------------*/
  431.  
  432.  
  433. /*---- FUNCION: void TGAescribirLinea(char *p, FILE *f,int bytes) ---------------
  434.  
  435.     Descripción:
  436.  
  437.         Esta función escribe una línea en un fichero TGA.
  438.  
  439.     Parámetros:
  440.  
  441.         char *p : puntero a buffer que alberga la línea
  442.         FILE *f : puntero al fichero
  443.         int bytes : numero de bytes por línea
  444.  
  445.     Retorno:
  446.  
  447.         Puntero a la estructura de la imagen o NULL si hubo error
  448.  
  449. ---- CODIGO: -----------------------------------------------------------------*/
  450.  
  451. void TGAescribirLinea(char *p, FILE *f,int bytes)
  452. {
  453. fwrite((char *)p,bytes,1,f);
  454. }
  455.  
  456. /*---- FIN FUNCION -----------------------------------------------------------*/